using System;
using System.Collections.Generic;
using ns26;
using ns27;
using Triton.Game.Mono;

namespace Triton.Game.Mapping
{
	[Attribute38("CollectionDeckTray")]
	public class CollectionDeckTray : MonoBehaviour
	{
		public enum DeckContentTypes
		{
			Decks,
			Cards,
			HeroSkin,
			CardBack,
			INVALID
		}

		[Attribute38("CollectionDeckTray.DeckContentScroll")]
		public class DeckContentScroll : MonoClass
		{
			public DeckContentTypes m_contentType => method_2<DeckContentTypes>("m_contentType");

			public GameObject m_scrollObject => method_3<GameObject>("m_scrollObject");

			public bool m_saveScrollPosition => method_2<bool>("m_saveScrollPosition");

			public Vector3 m_startPos => method_2<Vector3>("m_startPos");

			public float m_currentScroll => method_2<float>("m_currentScroll");

			public DeckContentScroll(IntPtr address, string className)
				: base(address, className)
			{
			}

			public DeckContentScroll(IntPtr address)
				: this(address, "DeckContentScroll")
			{
			}

			public void SaveStartPosition()
			{
				method_8("SaveStartPosition");
			}

			public Vector3 GetStartPosition()
			{
				return method_11<Vector3>("GetStartPosition", Array.Empty<object>());
			}

			public Vector3 GetCurrentPosition()
			{
				return method_11<Vector3>("GetCurrentPosition", Array.Empty<object>());
			}

			public void SaveCurrentScroll(float scroll)
			{
				method_8("SaveCurrentScroll", scroll);
			}

			public float GetCurrentScroll()
			{
				return method_11<float>("GetCurrentScroll", Array.Empty<object>());
			}
		}

		public UberText m_countLabelText => method_3<UberText>("m_countLabelText");

		public UberText m_countText => method_3<UberText>("m_countText");

		public UIBButton m_doneButton => method_3<UIBButton>("m_doneButton");

		public GameObject m_backArrow => method_3<GameObject>("m_backArrow");

		public UberText m_myDecksLabel => method_3<UberText>("m_myDecksLabel");

		public DeckTrayDeckListContent m_decksContent => method_3<DeckTrayDeckListContent>("m_decksContent");

		public DeckTrayCardListContent m_cardsContent => method_3<DeckTrayCardListContent>("m_cardsContent");

		public DeckTrayCardBackContent m_cardBackContent => method_3<DeckTrayCardBackContent>("m_cardBackContent");

		public DeckTrayHeroSkinContent m_heroSkinContent => method_3<DeckTrayHeroSkinContent>("m_heroSkinContent");

		public DeckBigCard m_deckBigCard => method_3<DeckBigCard>("m_deckBigCard");

		public UIBScrollable m_scrollbar => method_3<UIBScrollable>("m_scrollbar");

		public GameObject m_inputBlocker => method_3<GameObject>("m_inputBlocker");

		public TooltipZone m_deckHeaderTooltip => method_3<TooltipZone>("m_deckHeaderTooltip");

		public GameObject m_topCardPositionBone => method_3<GameObject>("m_topCardPositionBone");

		public Transform m_removeCardTutorialBone => method_3<Transform>("m_removeCardTutorialBone");

		public List<DeckContentScroll> m_scrollables => method_3<Class271<DeckContentScroll>>("m_scrollables")?.method_25();

		public DeckContentTypes m_currentContent => method_2<DeckContentTypes>("m_currentContent");

		public DeckContentTypes m_contentToSet => method_2<DeckContentTypes>("m_contentToSet");

		public bool m_settingNewMode => method_2<bool>("m_settingNewMode");

		public bool m_updatingTrayMode => method_2<bool>("m_updatingTrayMode");

		public CollectionDeckTray(IntPtr address, string className)
			: base(address, className)
		{
		}

		public CollectionDeckTray(IntPtr address)
			: this(address, "CollectionDeckTray")
		{
		}

		public static CollectionDeckTray Get()
		{
			return MonoClass.smethod_15<CollectionDeckTray>(TritonHs.MainAssemblyPath, "", "CollectionDeckTray", "Get", Array.Empty<object>());
		}

		public static void OnDeckTrayTileScrollVisibleAffected(GameObject obj, bool visible)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "CollectionDeckTray", "OnDeckTrayTileScrollVisibleAffected", obj, visible);
		}

		public void Awake()
		{
			method_8("Awake");
		}

		public void OnDestroy()
		{
			method_8("OnDestroy");
		}

		public void Start()
		{
			method_8("Start");
		}

		public bool CanPickupCard()
		{
			return method_11<bool>("CanPickupCard", Array.Empty<object>());
		}

		public void Initialize()
		{
			method_8("Initialize");
		}

		public void Unload()
		{
			method_8("Unload");
		}

		public void OnScenePreUnload(SceneMgr.Mode prevMode, PegasusScene prevScene, object userData)
		{
			method_8("OnScenePreUnload", prevMode, prevScene, userData);
		}

		public bool AddCard(EntityDef cardEntityDef, TAG_PREMIUM premium, DeckTrayDeckTileVisual deckTileToRemove, bool playSound, Actor animateActor, bool allowInvalid)
		{
			return method_11<bool>("AddCard", new object[6] { cardEntityDef, premium, deckTileToRemove, playSound, animateActor, allowInvalid });
		}

		public bool AddPreferredCard(EntityDef cardEntityDef, DeckTrayDeckTileVisual deckTileToRemove, bool playSound, Actor animateActor, bool allowInvalid)
		{
			return method_11<bool>("AddPreferredCard", new object[5] { cardEntityDef, deckTileToRemove, playSound, animateActor, allowInvalid });
		}

		public int RemoveClosestInvalidCard(EntityDef entityDef, int sameRemoveCount)
		{
			return method_11<int>("RemoveClosestInvalidCard", new object[2] { entityDef, sameRemoveCount });
		}

		public bool SetCardBack(Actor actor)
		{
			return method_11<bool>("SetCardBack", new object[1] { actor });
		}

		public void FlashDeckTemplateHighlight()
		{
			method_8("FlashDeckTemplateHighlight");
		}

		public void SetHeroSkin(Actor actor)
		{
			method_8("SetHeroSkin", actor);
		}

		public void HandleAddedCardDeckUpdate(EntityDef entityDef, TAG_PREMIUM premium, int newCount)
		{
			method_8("HandleAddedCardDeckUpdate", entityDef, premium, newCount);
		}

		public bool HandleDeletedCardDeckUpdate(string cardID)
		{
			return method_11<bool>("HandleDeletedCardDeckUpdate", new object[1] { cardID });
		}

		public bool RemoveCard(string cardID, TAG_PREMIUM premium, bool valid)
		{
			return method_11<bool>("RemoveCard", new object[3] { cardID, premium, valid });
		}

		public void ShowDeck(CollectionManagerDisplay.ViewMode viewMode, long deckID, bool isNewDeck)
		{
			method_8("ShowDeck", viewMode, deckID, isNewDeck);
		}

		public void EnterEditDeckModeForTavernBrawl()
		{
			method_8("EnterEditDeckModeForTavernBrawl");
		}

		public void ExitEditDeckModeForTavernBrawl()
		{
			method_8("ExitEditDeckModeForTavernBrawl");
		}

		public void AllowInput(bool allowed)
		{
			method_8("AllowInput", allowed);
		}

		public bool MouseIsOver()
		{
			return method_11<bool>("MouseIsOver", Array.Empty<object>());
		}

		public bool IsShowingDeckContents()
		{
			return method_11<bool>("IsShowingDeckContents", Array.Empty<object>());
		}

		public bool IsWaitingToDeleteDeck()
		{
			return method_11<bool>("IsWaitingToDeleteDeck", Array.Empty<object>());
		}

		public void DeleteEditingDeck(bool popNavigation)
		{
			method_8("DeleteEditingDeck", popNavigation);
		}

		public void CancelRenamingDeck()
		{
			method_8("CancelRenamingDeck");
		}

		public DeckBigCard GetDeckBigCard()
		{
			return method_14<DeckBigCard>("GetDeckBigCard", Array.Empty<object>());
		}

		public void ClearCountLabels()
		{
			method_8("ClearCountLabels");
		}

		public DeckTrayDeckTileVisual GetCardTileVisual(string cardID)
		{
			return method_15<DeckTrayDeckTileVisual>("GetCardTileVisual", new Class276.Enum20[1] { Class276.Enum20.String }, new object[1] { cardID });
		}

		public DeckTrayDeckTileVisual GetCardTileVisual(string cardID, TAG_PREMIUM premType)
		{
			return method_15<DeckTrayDeckTileVisual>("GetCardTileVisual", new Class276.Enum20[2]
			{
				Class276.Enum20.String,
				Class276.Enum20.ValueType
			}, new object[2] { cardID, premType });
		}

		public DeckTrayDeckTileVisual GetCardTileVisual(int index)
		{
			return method_15<DeckTrayDeckTileVisual>("GetCardTileVisual", new Class276.Enum20[1] { Class276.Enum20.I4 }, new object[1] { index });
		}

		public DeckTrayDeckTileVisual GetOrAddCardTileVisual(int index, bool affectedByScrollbar)
		{
			return method_14<DeckTrayDeckTileVisual>("GetOrAddCardTileVisual", new object[2] { index, affectedByScrollbar });
		}

		public DeckTrayContent GetCurrentContent()
		{
			return method_14<DeckTrayContent>("GetCurrentContent", Array.Empty<object>());
		}

		public DeckContentTypes GetCurrentContentType()
		{
			return method_11<DeckContentTypes>("GetCurrentContentType", Array.Empty<object>());
		}

		public void SetMyDecksLabelText(string text)
		{
			method_8("SetMyDecksLabelText", text);
		}

		public TooltipZone GetTooltipZone()
		{
			return method_14<TooltipZone>("GetTooltipZone", Array.Empty<object>());
		}

		public DeckTrayDeckListContent GetDecksContent()
		{
			return method_14<DeckTrayDeckListContent>("GetDecksContent", Array.Empty<object>());
		}

		public DeckTrayCardListContent GetCardsContent()
		{
			return method_14<DeckTrayCardListContent>("GetCardsContent", Array.Empty<object>());
		}

		public DeckTrayCardBackContent GetCardBackContent()
		{
			return method_14<DeckTrayCardBackContent>("GetCardBackContent", Array.Empty<object>());
		}

		public DeckTrayHeroSkinContent GetHeroSkinContent()
		{
			return method_14<DeckTrayHeroSkinContent>("GetHeroSkinContent", Array.Empty<object>());
		}

		public void SetTrayMode(DeckContentTypes contentType)
		{
			method_8("SetTrayMode", contentType);
		}

		public void Exit()
		{
			method_8("Exit");
		}

		public void UpdateTileVisuals()
		{
			method_8("UpdateTileVisuals");
		}

		public CollectionDeckBoxVisual GetEditingDeckBox()
		{
			return method_14<CollectionDeckBoxVisual>("GetEditingDeckBox", Array.Empty<object>());
		}

		public void DoneButtonPress(UIEvent e)
		{
			method_8("DoneButtonPress", e);
		}

		public bool OnBackOutOfDeckContents()
		{
			return method_11<bool>("OnBackOutOfDeckContents", Array.Empty<object>());
		}

		public bool OnBackOutOfDeckContentsImpl(bool deleteDeck)
		{
			return method_11<bool>("OnBackOutOfDeckContentsImpl", new object[1] { deleteDeck });
		}

		public bool OnBackOutOfCollectionScreen()
		{
			return method_11<bool>("OnBackOutOfCollectionScreen", Array.Empty<object>());
		}

		public void SaveCurrentDeckAndEnterDeckListMode()
		{
			method_8("SaveCurrentDeckAndEnterDeckListMode");
		}

		public void UpdateDoneButtonText()
		{
			method_8("UpdateDoneButtonText");
		}

		public bool IsUpdatingTrayMode()
		{
			return method_11<bool>("IsUpdatingTrayMode", Array.Empty<object>());
		}

		public void TryEnableScrollbar()
		{
			method_8("TryEnableScrollbar");
		}

		public void SaveScrollbarPosition(DeckContentTypes contentType)
		{
			method_8("SaveScrollbarPosition", contentType);
		}

		public void TryDisableScrollbar()
		{
			method_8("TryDisableScrollbar");
		}

		public void HideUnseenDeckTrays()
		{
			method_8("HideUnseenDeckTrays");
		}

		public void OnTouchScrollStarted()
		{
			method_8("OnTouchScrollStarted");
		}

		public void OnTouchScrollEnded()
		{
			method_8("OnTouchScrollEnded");
		}

		public void OnCardTilePress(DeckTrayDeckTileVisual cardTile)
		{
			method_8("OnCardTilePress", cardTile);
		}

		public void OnCardTileTap(DeckTrayDeckTileVisual cardTile)
		{
			method_8("OnCardTileTap", cardTile);
		}

		public void OnCardTileHeld(DeckTrayDeckTileVisual cardTile)
		{
			method_8("OnCardTileHeld", cardTile);
		}

		public void OnCardTileOver(DeckTrayDeckTileVisual cardTile)
		{
			method_8("OnCardTileOver", cardTile);
		}

		public void OnCardTileOut(DeckTrayDeckTileVisual cardTile)
		{
			method_8("OnCardTileOut", cardTile);
		}

		public void OnCardTileRelease(DeckTrayDeckTileVisual cardTile)
		{
			method_8("OnCardTileRelease", cardTile);
		}

		public void RemoveCardTile(DeckTrayDeckTileVisual cardTile, bool removeAllCopies)
		{
			method_8("RemoveCardTile", cardTile, removeAllCopies);
		}

		public void OnCardCountUpdated(int cardCount)
		{
			method_8("OnCardCountUpdated", cardCount);
		}

		public void OnDeckCountUpdated(int deckCount)
		{
			method_8("OnDeckCountUpdated", deckCount);
		}

		public void OnBusyWithDeck(bool busy)
		{
			method_8("OnBusyWithDeck", busy);
		}

		public void OnTaggedDeckChanged(CollectionManager.DeckTag tag, CollectionDeck newDeck, CollectionDeck oldDeck, object callbackData)
		{
			method_8("OnTaggedDeckChanged", tag, newDeck, oldDeck, callbackData);
		}

		public void ShowDeckBigCard(DeckTrayDeckTileVisual cardTile, float delay)
		{
			method_8("ShowDeckBigCard", cardTile, delay);
		}

		public void HideDeckBigCard(DeckTrayDeckTileVisual cardTile, bool force)
		{
			method_8("HideDeckBigCard", cardTile, force);
		}

		public void OnCMViewModeChanged(CollectionManagerDisplay.ViewMode prevMode, CollectionManagerDisplay.ViewMode mode, CollectionManagerDisplay.ViewModeData userdata, bool triggerResponse)
		{
			method_8("OnCMViewModeChanged", prevMode, mode, userdata, triggerResponse);
		}

		public DeckContentTypes GetContentTypeFromViewMode(CollectionManagerDisplay.ViewMode viewMode)
		{
			return method_11<DeckContentTypes>("GetContentTypeFromViewMode", new object[1] { viewMode });
		}

		public void FireModeSwitchedEvent()
		{
			method_8("FireModeSwitchedEvent");
		}

		public void OnHeroAssigned(string cardID)
		{
			method_8("OnHeroAssigned", cardID);
		}
	}
}
